//package com.kun.companion.core.util;
//
//import cn.hutool.core.collection.ListUtil;
//import cn.hutool.core.util.ReflectUtil;
//import cn.hutool.core.util.StrUtil;
//import com.kun.companion.core.exception.BizException;
//import io.github.classgraph.*;
//import org.slf4j.Logger;
//import org.slf4j.LoggerFactory;
//
//import java.lang.reflect.Constructor;
//import java.lang.reflect.Field;
//import java.util.ArrayList;
//import java.util.Arrays;
//import java.util.List;
//import java.util.stream.Collectors;
//
///**
// * TODO
// *
// * @author gzc
// * @since 2025/1/26 21:58
// **/
//public class ClassGraphUtil {
//    private static final Logger log = LoggerFactory.getLogger(ClassGraphUtil.class);
//
//
//    public static Object newInstance(String packagePath) {
//        try {
//            Constructor<?> constructor = Class.forName(packagePath).getConstructor();
//            return constructor.newInstance();
//        } catch (Exception e) {
//            throw new BizException(StrUtil.format("根据类路径【{}】创建实例对象失败 ", packagePath), e);
//        }
//    }
//
//    public static <T> T newInstance(Class<T> cls) {
//        if (cls == null) {
//            return null;
//        }
//        try {
//            Constructor<T> constructor = cls.getConstructor();
//            return constructor.newInstance();
//        } catch (Exception e) {
//            throw new BizException(StrUtil.format("根据类对象【{}】创建实例对象失败 ", cls), e);
//        }
//    }
//
//    /**
//     * 扫描类路径并查找所有带有指定注解的类
//     *
//     * @param annotationClass 要查找的注解类
//     * @return 带有指定注解的类的全限定名列表
//     */
//    public static List<String> findClassesWithAnnotation(Class<?> annotationClass) {
//        try (ScanResult scanResult = new ClassGraph()
//                .enableAllInfo() // 启用所有信息（类、方法、注解等）
//                .scan()) { // 开始扫描
//
//            // 获取所有带有指定注解的类信息
//            ClassInfoList classInfos = scanResult.getClassesWithAnnotation(annotationClass.getName());
//
//            // 将类信息转换为全限定名列表
//            return classInfos.stream()
//                    .map(ClassInfo::getName)
//                    .collect(Collectors.toList());
//        }
//    }
//
//    /**
//     * 扫描类路径并查找所有实现指定接口的类
//     *
//     * @param interfaceClass 要查找的接口类
//     * @return 实现指定接口的类的全限定名列表
//     */
//    public static List<String> findClassesImplementingInterface(Class<?> interfaceClass) {
//        try (ScanResult scanResult = new ClassGraph()
//                .enableAllInfo() // 启用所有信息（类、方法、注解等）
//                .scan()) { // 开始扫描
//
//            // 获取所有实现指定接口的类信息
//            ClassInfoList classInfos = scanResult.getClassesImplementing(interfaceClass.getName());
//
//            // 将类信息转换为全限定名列表
//            return classInfos.stream()
//                    .map(ClassInfo::getName)
//                    .collect(Collectors.toList());
//        }
//    }
//
//    /**
//     * 扫描类路径并查找所有继承指定父类的类
//     *
//     * @param superClass 要查找的父类
//     * @return 继承指定父类的类的全限定名列表
//     */
//    public static List<String> findClassesExtendingSuperClass(Class<?> superClass) {
//        try (ScanResult scanResult = new ClassGraph()
//                .enableAllInfo() // 启用所有信息（类、方法、注解等）
//                .scan()) { // 开始扫描
//
//            // 获取所有继承指定父类的类信息
//            ClassInfoList classInfos = scanResult.getSubclasses(superClass.getName());
//
//            // 将类信息转换为全限定名列表
//            return classInfos.stream()
//                    .map(ClassInfo::getName)
//                    .collect(Collectors.toList());
//        }
//    }
//
//    /**
//     * 查找特定包下的所有类
//     *
//     * @param packageName 包名
//     * @return 包下所有类的全限定名列表
//     */
//    public static List<String> findClassesInPackage(String packageName) {
//        try (ScanResult scanResult = new ClassGraph()
//                .enableAllInfo() // 启用所有信息
//                .acceptPackages(packageName) // 只扫描指定包
//                .scan()) { // 开始扫描
//
//            // 获取包下的所有类信息
//            ClassInfoList classInfos = scanResult.getAllClasses();
//
//            // 将类信息转换为全限定名列表
//            return classInfos.stream()
//                    .map(ClassInfo::getName)
//                    .collect(Collectors.toList());
//        }
//    }
//
//    /**
//     * 查找带有特定方法签名的类
//     *
//     * @param methodName     方法名
//     * @param parameterTypes 方法参数类型
//     * @return 包含指定方法的类的全限定名列表
//     */
//    public static List<String> findClassesWithMethod(String methodName, Class<?>... parameterTypes) {
//        try (ScanResult scanResult = new ClassGraph()
//                .enableAllInfo() // 启用所有信息
//                .scan()) { // 开始扫描
//
//            // 获取所有类信息
//            ClassInfoList classInfos = scanResult.getAllClasses();
//
//            // 将参数类型转换为字符串数组
//            String[] parameterTypeNames = Arrays.stream(parameterTypes)
//                    .map(Class::getName)
//                    .toArray(String[]::new);
//
//            // 过滤出包含指定方法的类
//            return classInfos.stream()
//                    .filter(classInfo -> {
//                        // 查找类中是否包含指定方法
//                        List<MethodInfo> methods = classInfo.getMethodInfo(methodName);
//                        return methods.stream()
//                                .anyMatch(method -> {
//                                    // 获取方法的参数类型名称
//                                    List<MethodParameterInfo> parameters = List.of(method.getParameterInfo());
//                                    String[] methodParameterTypeNames = parameters.stream()
//                                            .map(MethodParameterInfo::getTypeSignature)
//                                            .toArray(String[]::new);
//
//                                    // 比较参数类型名称
//                                    return Arrays.equals(methodParameterTypeNames, parameterTypeNames);
//                                });
//                    })
//                    .map(ClassInfo::getName)
//                    .collect(Collectors.toList());
//        }
//    }
//
//    /**
//     * 查找类的字段信息
//     *
//     * @param className 类的全限定名
//     * @return 类的字段信息列表
//     */
//    public static List<String> findClassFields(String className) {
//        try (ScanResult scanResult = new ClassGraph()
//                .enableAllInfo() // 启用所有信息
//                .scan()) { // 开始扫描
//
//            // 获取指定类的信息
//            ClassInfo classInfo = scanResult.getClassInfo(className);
//            if (classInfo == null) {
//                throw new IllegalArgumentException("Class not found: " + className);
//            }
//
//            // 获取类的字段信息
//            return classInfo.getFieldInfo().stream()
//                    .map(fieldInfo -> fieldInfo.getTypeSignature() + " " + fieldInfo.getName())
//                    .collect(Collectors.toList());
//        }
//    }
//
//    public static Class<?> forName(String className) {
//        try {
//            if (StrUtil.isNotBlank(className)) {
//                return Class.forName(className);
//            }
//        } catch (ClassNotFoundException e) {
//            throw new BizException("找不到类 -> " + className);
//        }
//        return null;
//    }
//
//    public static List<Field> getFieldList(Class<?> clazz) {
//        if (clazz == null) {
//            return new ArrayList<>(0);
//        }
//        Field[] fields = clazz.getDeclaredFields();
//        String clazzName = clazz.getName();
//        int indexOf = clazzName.indexOf("$");
//        if (indexOf > 1) {
//            String substring = clazzName.substring(0, indexOf);
//            fields = ReflectUtil.getFields(forName(substring));
//        }
//        return ListUtil.toList(fields);
//    }
//
//    /**
//     * 查找类的依赖关系
//     *
//     * @param className 类的全限定名
//     * @return 该类依赖的其他类的全限定名列表
//     */
//    public static List<String> findClassDependencies(String className) {
//        try (ScanResult scanResult = new ClassGraph()
//                .enableAllInfo() // 启用所有信息
//                .scan()) { // 开始扫描
//
//            // 获取指定类的信息
//            ClassInfo classInfo = scanResult.getClassInfo(className);
//            if (classInfo == null) {
//                throw new IllegalArgumentException("Class not found: " + className);
//            }
//
//            // 获取类的依赖关系
//            return classInfo.getClassDependencies().stream()
//                    .map(ClassInfo::getName)
//                    .collect(Collectors.toList());
//        }
//    }
//
//    /**
//     * 扫描指定包路径下并查找所有继承指定父类的类
//     *
//     * @param packageName 包名
//     * @param superClass  父类
//     * @return 包下继承指定父类的类的全限定名列表
//     */
//    public static List<String> findClassesInPackageExtendingSuperClass(String packageName, Class<?> superClass) {
//        try (ScanResult scanResult = new ClassGraph()
//                .enableAllInfo()
//                .acceptPackages(packageName)
//                .scan()) {
//
//            ClassInfoList classInfos = scanResult.getSubclasses(superClass.getName());
//            return classInfos.stream()
//                    .map(ClassInfo::getName)
//                    .collect(Collectors.toList());
//        }
//    }
//
//    /**
//     * 扫描指定包路径数组下并查找所有继承指定父类的类
//     *
//     * @param packageNames 包名数组
//     * @param superClass   父类
//     * @return 指定包下继承父类的类的全限定名列表
//     */
//    public static List<String> findClassesInPackagesExtendingSuperClass(String[] packageNames, Class<?> superClass) {
//        try (ScanResult scanResult = new ClassGraph()
//                .enableAllInfo()
//                .acceptPackages(packageNames)
//                .scan()) {
//
//            ClassInfoList classInfos = scanResult.getSubclasses(superClass.getName());
//            return classInfos.stream()
//                    .map(ClassInfo::getName)
//                    .collect(Collectors.toList());
//        }
//    }
//
//    /**
//     * 扫描指定的包路径数组，查找所有实现指定接口的类
//     *
//     * @param interfaceClass 要查找的接口类
//     * @param packageNames   要扫描的包路径数组
//     * @return 实现指定接口的类的全限定名列表
//     */
//    public static List<String> findClassesImplementingInPackages(String[] packageNames, Class<?> interfaceClass) {
//        if (interfaceClass == null) {
//            throw new IllegalArgumentException("interfaceClass cannot be null");
//        }
//        if (packageNames == null) {
//            throw new IllegalArgumentException("packageNames cannot be null");
//        }
//
//        try (ScanResult scanResult = new ClassGraph()
//                .enableAllInfo()
//                .acceptPackages(packageNames)
//                .scan()) {
//
//            ClassInfoList classInfos = scanResult.getClassesImplementing(interfaceClass.getName());
//            return classInfos.stream()
//                    .map(ClassInfo::getName)
//                    .collect(Collectors.toList());
//        }
//    }
//
//}
